/**
 * 用户管理工具类
 * 负责处理登录、注册、登录状态管理等功能
 */

const api = require('./api');

// 用户登录状态存储键名
const TOKEN_KEY = 'token';
const USER_INFO_KEY = 'userInfo';
const OPENID_KEY = 'openid';

/**
 * 用户管理器
 */
const userManager = {
  /**
   * 获取用户openid
   * @returns {Promise} 返回openid
   */
  getOpenid() {
    return new Promise((resolve, reject) => {
      // 先从缓存中获取
      const openid = wx.getStorageSync(OPENID_KEY);
      if (openid) {
        resolve(openid);
        return;
      }

      // 获取登录凭证
      wx.login({
        success: loginRes => {
          if (loginRes.code) {
            // 使用code调用后端接口获取openid
            const acc = wx.getAccountInfoSync()
            const app_id = acc.miniProgram.appId;
            api.user.getOpenid({
              code: loginRes.code,
              app_id:app_id
            })
            .then(res => {
              if (res && res.success && res.data && res.data.openid) {
                const openid = res.data.openid;
                // 存储到本地
                wx.setStorageSync(OPENID_KEY, openid);
                resolve(openid);
              } else {
                reject(new Error(res.message || '获取openid失败'));
              }
            })
            .catch(err => {
              console.error('获取openid失败', err);
              reject(err);
            });
          } else {
            reject(new Error('微信登录失败'));
          }
        },
        fail: err => {
          console.error('微信登录失败', err);
          reject(err);
        }
      });
    });
  },

  /**
   * 检查用户是否登录
   * @returns {boolean} 是否已登录
   */
  isLoggedIn() {
    const token = wx.getStorageSync(TOKEN_KEY);
    const userInfo = wx.getStorageSync(USER_INFO_KEY);
    return !!token && !!userInfo;
  },

  /**
   * 保存用户登录状态
   * @param {Object} data - 包含token和用户信息
   */
  saveLoginState(data) {
    if (data.token) {
      wx.setStorageSync(TOKEN_KEY, data.token);
    }
    if (data.userInfo) {
      wx.setStorageSync(USER_INFO_KEY, data.userInfo);
    }
    if (data.openid) {
      wx.setStorageSync(OPENID_KEY, data.openid);
    }

    // 更新全局状态
    const app = getApp();
    app.globalData.isLoggedIn = true;
    app.globalData.userInfo = data.userInfo;
    app.globalData.openid = data.openid;
  },

  /**
   * 清除登录状态
   */
  clearLoginState() {
    wx.removeStorageSync(TOKEN_KEY);
    wx.removeStorageSync(USER_INFO_KEY);
    // 不清除openid，保留用户唯一标识

    // 更新全局状态
    const app = getApp();
    app.globalData.isLoggedIn = false;
    app.globalData.userInfo = null;
  },

  /**
   * 获取用户信息
   * @returns {Object|null} 用户信息
   */
  getUserInfo() {
    return wx.getStorageSync(USER_INFO_KEY);
  },

  /**
   * 获取token
   * @returns {string|null} token
   */
  getToken() {
    return wx.getStorageSync(TOKEN_KEY);
  },

  /**
   * 自动登录
   * 1. 获取openid
   * 2. 查询后端是否已有该用户记录
   * 3. 如有，直接登录；如无，返回false
   * @returns {Promise} 登录结果，成功返回用户信息，失败返回false
   */
  autoLogin() {
    return new Promise((resolve, reject) => {
      // 已登录状态，直接返回用户信息
      if (this.isLoggedIn()) {
        resolve(this.getUserInfo());
        return;
      }

      // 获取openid
      this.getOpenid()
        .then(openid => {
          // 调用后端接口，查询用户信息
          return api.user.checkUserExist(openid);
        })
        .then(res => {
          if (res && res.success && res.data && res.data.exists) {
            // 用户存在，保存登录状态
            this.saveLoginState({
              token: res.data.token,
              userInfo: res.data.userInfo,
              openid: res.data.openid
            });
            resolve(res.data.userInfo);
          } else {
            // 用户不存在，需要引导注册
            resolve(false);
          }
        })
        .catch(err => {
          console.error('自动登录失败', err);
          reject(err);
        });
    });
  },

  /**
   * 使用手机号登录/注册
   * @param {Object} phoneData - 获取到的手机号数据
   * @returns {Promise} 注册结果
   */
  loginWithPhone(phoneData) {
    return new Promise((resolve, reject) => {
      // 先获取登录凭证
      wx.login({
        success: loginRes => {
          if (loginRes.code) {
            // 获取openid
            this.getOpenid()
              .then(openid => {
                // 调用后端接口，注册或登录
                const acc = wx.getAccountInfoSync()
                const app_id = acc.miniProgram.appId;
                return api.user.loginOrRegister({
                  app_id:app_id,
                  openid: openid,
                  code: loginRes.code,
                  encryptedData: phoneData.encryptedData,
                  iv: phoneData.iv,
                  userInfo: getApp().globalData.userInfo || {}
                });
              })
              .then(res => {
                if (res && res.success&& res.data) {
                  // 保存登录状态
                  this.saveLoginState({
                    token: res.data.token,
                    userInfo: res.data.userInfo,
                    openid: res.data.openid
                  });
                  resolve({
                    userInfo: res.data.userInfo,
                    isNewUser: res.data.isNewUser
                  });
                } else {
                  reject(new Error(res.msg || '登录失败'));
                }
              })
              .catch(err => {
                console.error('手机号登录失败', err);
                reject(err);
              });
          } else {
            reject(new Error('微信登录失败'));
          }
        },
        fail: err => {
          console.error('微信登录失败', err);
          reject(err);
        }
      });
    });
  },

  /**
   * 使用验证码登录
   * @param {Object} data - 包含手机号和验证码的对象
   * @returns {Promise} 登录结果
   */
  loginWithCode(data) {
    return new Promise((resolve, reject) => {
      // 获取微信code
      wx.login({
        success: loginRes => {
          const acc = wx.getAccountInfoSync()
          const app_id = acc.miniProgram.appId;
          // 组装参数
          const params = {
            app_id:app_id,
            phone: data.phone,
            code: data.code
          };
          
          // 如果有微信code，添加到参数中
          if (loginRes.code) {
            params.wxCode = loginRes.code;
          }
          
          // 调用后端接口
          api.user.loginWithCode(params)
            .then(res => {
              if (res && res.success && res.data) {
                // 保存登录状态
                this.saveLoginState({
                  token: res.data.token,
                  userInfo: res.data.userInfo,
                  openid: res.data.openid
                });
                resolve({
                  userInfo: res.data.userInfo,
                  isNewUser: res.data.isNewUser
                });
              } else {
                reject(new Error(res.msg || '登录失败'));
              }
            })
            .catch(err => {
              console.error('验证码登录失败', err);
              reject(err);
            });
        },
        fail: err => {
          // 没有微信code也尝试登录
          api.user.loginWithCode({
            phone: data.phone,
            code: data.code
          })
            .then(res => {
              if (res && res.success && res.data) {
                // 保存登录状态
                this.saveLoginState({
                  token: res.data.token,
                  userInfo: res.data.userInfo,
                  openid: res.data.openid
                });
                resolve({
                  userInfo: res.data.userInfo,
                  isNewUser: res.data.isNewUser
                });
              } else {
                reject(new Error(res.msg || '登录失败'));
              }
            })
            .catch(loginErr => {
              console.error('验证码登录失败', loginErr);
              reject(loginErr);
            });
        }
      });
    });
  },
  
  /**
   * 发送验证码
   * @param {string} phone - 手机号
   * @returns {Promise} 发送结果
   */
  sendVerifyCode(phone) {
    return api.user.sendVerifyCode({ phone });
  },
  
  /**
   * 退出登录
   * @returns {Promise} 退出结果
   */
  logout() {
    return new Promise((resolve) => {
      // 清除本地登录状态
      this.clearLoginState();
      
      // 调用后端接口
      api.user.logout()
        .then(() => {
          resolve(true);
        })
        .catch(() => {
          // 即使后端调用失败，也认为退出成功
          resolve(true);
        });
    });
  },

  /**
   * 更新用户信息
   * @param {Object} data - 用户信息
   * @returns {Promise} 更新结果
   */
  updateUserInfo(data) {
    return new Promise((resolve, reject) => {
      api.user.updateUserInfo(data)
        .then(res => {
          if (res && res.success) {
            // 更新本地存储的用户信息
            const userInfo = this.getUserInfo();
            if (userInfo) {
              if (data.nickname) userInfo.nickname = data.nickname;
              if (data.avatar) userInfo.avatar = data.avatar;
              if (data.gender) userInfo.gender = data.gender;
              
              wx.setStorageSync(USER_INFO_KEY, userInfo);
              
              // 更新全局状态
              const app = getApp();
              app.globalData.userInfo = userInfo;
            }
            
            resolve(true);
          } else {
            reject(new Error(res.msg || '更新用户信息失败'));
          }
        })
        .catch(err => {
          console.error('更新用户信息失败', err);
          reject(err);
        });
    });
  }
};

module.exports = userManager; 